import Database from 'better-sqlite3'
import { fileURLToPath } from 'url'
import { dirname, join } from 'path'
import { USDT_PRECISION } from '../config.js'

const __filename = fileURLToPath(import.meta.url)
const __dirname = dirname(__filename)

// 数据库路径
const dbPath = process.env.DB_PATH || join(__dirname, '../data/wallet.db')

console.log('🔧 开始修复数据库余额...')
console.log(`数据库路径: ${dbPath}`)
console.log(`USDT_PRECISION: ${USDT_PRECISION}`)

const db = new Database(dbPath)

try {
  // 查询所有钱包
  const wallets = db.prepare('SELECT id, user_id, currency, balance FROM wallets').all()
  
  console.log(`\n找到 ${wallets.length} 个钱包`)
  
  let fixedCount = 0
  let totalFixed = 0
  
  for (const wallet of wallets) {
    const originalBalance = wallet.balance || 0
    const balance = typeof originalBalance === 'number' ? originalBalance : parseFloat(originalBalance) || 0
    
    console.log(`\n钱包 ID: ${wallet.id}`)
    console.log(`  用户: ${wallet.user_id}`)
    console.log(`  币种: ${wallet.currency}`)
    console.log(`  当前余额: ${balance}`)
    
    if (wallet.currency === 'USDT') {
      // 判断是否需要转换
      // 如果余额 >= 1000000000（10亿），很可能是原始值，需要转换
      if (balance >= 1000000000) {
        const normalizedBalance = balance / USDT_PRECISION
        console.log(`  判断: 余额 >= 10亿，可能是原始值`)
        console.log(`  转换后余额: ${normalizedBalance}`)
        
        // 更新数据库
        db.prepare('UPDATE wallets SET balance = ?, updated_at = datetime(\'now\') WHERE id = ?')
          .run(normalizedBalance, wallet.id)
        
        fixedCount++
        totalFixed += (balance - normalizedBalance)
        console.log(`  ✅ 已修复（原始值 -> 标准值）`)
      } else if (balance >= 1 && balance < 1000000000) {
        // 如果余额在 1 到 10亿之间，可能是部分转换错误的值
        // 例如：如果应该是 10130000000，但存储成了 101300
        // 检查：如果余额 * 100000 后接近 USDT_PRECISION 的倍数，可能是少了几个0
        const possibleOriginal = balance * 100000
        if (possibleOriginal >= 1000000000 && possibleOriginal % 1000000000 === 0) {
          const normalizedBalance = possibleOriginal / USDT_PRECISION
          console.log(`  判断: 可能是少了几个0的原始值`)
          console.log(`  推测原始值: ${possibleOriginal}`)
          console.log(`  转换后余额: ${normalizedBalance}`)
          
          // 更新数据库
          db.prepare('UPDATE wallets SET balance = ?, updated_at = datetime(\'now\') WHERE id = ?')
            .run(normalizedBalance, wallet.id)
          
          fixedCount++
          totalFixed += (balance - normalizedBalance)
          console.log(`  ✅ 已修复（补0后转换）`)
        } else {
          // 尝试直接转换看看是否合理
          const testNormalized = balance / USDT_PRECISION
          if (testNormalized < 0.0001) {
            // 如果转换后太小（< 0.0001），可能是原始值但数值较小
            // 或者需要乘以某个倍数
            // 检查是否是 101300 -> 应该是 10130000000
            const expectedOriginal = balance * 100000
            if (expectedOriginal >= 1000000000) {
              const normalizedBalance = expectedOriginal / USDT_PRECISION
              console.log(`  判断: 可能是少了5个0的原始值（${balance} -> ${expectedOriginal}）`)
              console.log(`  转换后余额: ${normalizedBalance}`)
              
              // 更新数据库
              db.prepare('UPDATE wallets SET balance = ?, updated_at = datetime(\'now\') WHERE id = ?')
                .run(normalizedBalance, wallet.id)
              
              fixedCount++
              totalFixed += (balance - normalizedBalance)
              console.log(`  ✅ 已修复（补5个0后转换）`)
            } else {
              console.log(`  ⚠️  余额看起来异常，但无法自动修复`)
            }
          } else {
            console.log(`  ℹ️  余额可能是标准值，无需修复`)
          }
        }
      } else {
        console.log(`  ℹ️  余额 < 1，可能是标准值，无需修复`)
      }
    } else {
      console.log(`  ℹ️  非 USDT 币种，跳过`)
    }
  }
  
  console.log(`\n✅ 修复完成！`)
  console.log(`修复了 ${fixedCount} 个钱包的余额`)
  if (fixedCount > 0) {
    console.log(`总计调整: ${totalFixed.toFixed(12)} USDT`)
  }
  
} catch (error) {
  console.error('❌ 修复失败:', error)
  process.exit(1)
} finally {
  db.close()
}

